//package com.qkjia.zqkspringshell.yuanma;
//
//import org.springframework.beans.factory.annotation.Qualifier;
//import org.springframework.context.annotation.Bean;
//import org.springframework.context.annotation.Configuration;
//import org.springframework.context.annotation.Import;
//import org.springframework.shell.*;
//import org.springframework.shell.result.ResultHandlerConfig;
//import org.springframework.shell.standard.ShellComponent;
//import org.springframework.shell.standard.ShellMethod;
//import org.springframework.util.ReflectionUtils;
//
//import javax.annotation.PostConstruct;
//import java.io.IOException;
//import java.lang.reflect.Method;
//import java.util.List;
//import java.util.stream.Collectors;
//
//import static javafx.stage.FileChooser.ExtensionFilter.validateArgs;
//import static org.springframework.context.annotation.ParserStrategyUtils.resolveArgs;
//import static org.springframework.shell.Shell.NO_INPUT;
//
///**
// * 5.SpringShell源码分析-命令扫描与执行
//
// * 上篇从源码分析了SpringShell的ApplicationRunner, 本文笔者从源码分析一下自定义命令的扫描和解析过程.
//
// */
//@ShellComponent
//public class minglingsaomiao {
//
//    1. 解析自定义命令
//1.1 注入Shell 组件
//    SpringShell 会在SpringShellAutoConfiguration 配置类中使用@Bean 方式向Spring 容器中注入Shell 组件.
//
//    // 源码:org.springframework.shell.SpringShellAutoConfiguration
//    @Configuration
//    @Import(ResultHandlerConfig.class)
//    public class SpringShellAutoConfiguration {
//
//        // 省略其它bean...
//
//        @Bean
//        public Shell shell(@Qualifier("main") ResultHandler resultHandler) {
//            return new Shell(resultHandler);
//        }
//
//    }
//
//
//        1.2 执行Shell 初始化方法, 完成自定义命令解析工作
//    由于Shell 类定义时, 使用JSR250注解@PostConstruct
//    定义了对象初始化方法, 因此在Spring 容器创建Shell 实例之后, 会执行shell实例的gatherMethodTargets()方法来完成自定义命令的解析工作.
//
//    创建ConfigurableCommandRegistry, 用于在注册命令时, 临时存储所有自定义命令和方法的映射关系.
//            获取所有的目标方法注册器, 会获取到StandardMethodTargetRegistrar 对象, 调用其register 方法, 此方法会将解析到的所有命令方法注册到ConfigurableCommandRegistry中
//    获取已注册的所有命令, 保存在methodTargets 属性中, 用于后续使用.
//    对所有命令对应的方法做参数校验
//// 源码: org.springframework.shell.Shell#gatherMethodTargets
//    @PostConstruct
//    public void gatherMethodTargets() throws Exception {
//        // 创建ConfigurableCommandRegistry, 存储所有命令与方法的映射关系.
//        ConfigurableCommandRegistry registry = new ConfigurableCommandRegistry();
//
//        // 获取所有的目标方法注册器, 会获取到StandardMethodTargetRegistrar
//        for (MethodTargetRegistrar resolver : applicationContext.getBeansOfType(MethodTargetRegistrar.class).values()) {
//            // 调用StandardMethodTargetRegistrar 的register 方法, 将扫描到的所有命令注册到 ConfigurableCommandRegistry 中
//            resolver.register(registry);
//        }
//        // 获取ConfigurableCommandRegistry 中已注册的所有命令, 存入属性变量methodTargets 中, 类型为:　Map<String, MethodTarget>
//        methodTargets = registry.listCommands();
//
//        // 对所有命令做参数校验
//        methodTargets.values().forEach(this::validateParameterResolvers);
//    }
//
//        1.3 解析所有ShellComponent组件, 注册自定义命令
//    从IOC容器中获取所有使用@ShellComponent定义的组件.
//            遍历解析所有ShellComponent组件, 对每个组件的ShellMehtod 方法进行遍历
//    处理命令别名, 将驼峰风格修改为-连接方式. 如addInt 别名为add-int
//            处理命令组名, 优先使用方法定义的组名, 其次是类指定的组名, 再次是包指定的组名, 最后是默认的组名
//    遍历所有别名, 对每个别名进行注册
//            获取限制命令是否可用的指示器
//    创建命令映射对象MethodTarget
//            将命令注册到ConfigurableCommandRegistry中, 即存储在ConfigurableCommandRegistry的map中
//    同时也将命令添加到属性commands中, toString中使用.
////　源码：org.springframework.shell.standard.StandardMethodTargetRegistrar#register
//    @Override
//    public void register(ConfigurableCommandRegistry registry) {
//        // 通过注解类型方式, 获取容器中所有使用@ShellComponet 注解修饰的组件
//        Map<String, Object> commandBeans = applicationContext.getBeansWithAnnotation(ShellComponent.class);
//
//        // 遍历所有的ShellComponet 组件
//        for (Object bean : commandBeans.values()) {
//            Class<?> clazz = bean.getClass();
//            // 反射处理ShellComponet 组件中的所有使用@ShellMethod 注解修饰的方法方法
//            ReflectionUtils.doWithMethods(clazz, method -> {
//
//                ShellMethod shellMapping = method.getAnnotation(ShellMethod.class);
//
//                // 处理方法别名, 即@ShellMethod 的key属性
//                String[] keys = shellMapping.key();
//                if (keys.length == 0) {
//                    // 对别名做转换, 将驼峰风格修改为使用-连接的方式
//                    keys = new String[] { Utils.unCamelify(method.getName()) };
//                }
//
//                // 获取组名: 会先判断方法是否指定了组名, 否则判断类是否定义了组名, 否则判断包是否定义了组名, 否则返回默认组名
//                String group = getOrInferGroup(method);
//
//                // 遍历所有的别名, 每个别名都注册一次
//                for (String key : keys) {
//                    // 获取所有的限制是否可用的指示器
//                    Supplier<Availability> availabilityIndicator = findAvailabilityIndicator(keys, bean, method);
//
//                    // 创建命令对应的MethodTarget
//                    MethodTarget target = new MethodTarget(method, bean, new Command.Help(shellMapping.value(), group), availabilityIndicator);
//
//                    // 将命令注册到ConfigurableCommandRegistry 中
//                    registry.register(key, target);
//
//                    // 也将命令添加到属性commands中, toString中使用
//                    commands.put(key, target);
//                }
//            }, method -> method.getAnnotation(ShellMethod.class) != null);
//        }
//    }
//
//        2. Shell 交互式命令运行逻辑
//    从笔者上一篇博客中, 我们知道SpringShell启动之后, 会调用ApplicationRunner的run方法来启动应用, 而run方法核心就是调用Shell.run()方法.Shell的run方法是一个循环, 会一直从ApplicationRunner 提供的InputProvider中获取命令, 并执行, 直到获取的命令为null时, 终止循环, 结束程序运行.
//
//            2.1 核心循环流程
//            创建变量result, 保存命令执行结果
//    启动循环, 循环终止条件为:
//    返回结果为ExitRequest实例时, 当执行quite/exit命令时, 返回ExitRequest.　参阅源码: org.springframework.shell.standard.commands.Quit#quit
//    当从InputProvider中读取返回值为null 时, 通过break跳出循环
//    从InputProvider中获取一条输入命令
//判断InputProvider.readInput()返回值是否为null, 是的话直接跳出循环
//            调用evaluate方法, 执行命令, 获取命令返回值
//    判断返回结果, 如果返回结果正常, 则处理返回结果.
//    public void run(InputProvider inputProvider) throws IOException {
//        // 自定义保存命令执行结果
//        Object result = null;
//
//        // 无限循环, 知道result为退出嘛
//        while (!(result instanceof ExitRequest)) {
//            Input input;
//
//            // 从输入源中读取一条输入
//            try {
//                input = inputProvider.readInput();
//            }
//            catch (Exception e) {
//                resultHandler.handleResult(e);
//                continue;
//            }
//
//            // 当读取的输入为null时, 跳出循环, 结束此shell的运行
//            if (input == null) {
//                break;
//            }
//
//            // 执行命令, 返回执行结果
//            result = evaluate(input);
//
//            // 结果不是new Object 或 ExitRequest 实例时, 处理结果
//            if (result != NO_INPUT && !(result instanceof ExitRequest)) {
//                resultHandler.handleResult(result);
//            }
//        }
//    }
//
//        2.2 执行命令逻辑
//    输入命令为空, 则返回new Object
//    格式化命令, 将命令中多余的空白符,都替换为单个空格
//    提取输入命令中的命令(不带参数的)
//    将输入命令按空格分隔成数组
//    如果命令不为空:
//    从shell.methodTargets 属性中获取命令的映射关系
//    获取命令的限制可用条件, 用于判断当前命令是否可执行
//    如果命令可执行:
//    获取命令的参数
//            获取命令对应的方法
//    解析并校验命令传入的参数
//            反射调用命令对应的方法, 并返回方法返回值
//    命令不可执行, 则返回命令不可用异常信息
//    命令找不到, 返回无此命令的异常信息.
//    // 源码:org.springframework.shell.Shell#evaluate
//// 假定传入参数为  add    2    3
//    public Object evaluate(Input input) {
//        // 如果input 为空, 返回New Object()
//        if (noInput(input)) {
//            return NO_INPUT;
//        }
//
//        // 格式化命令, 将多个空格转换为单个空格. 转化后line为add 2 3
//        String line = input.words().stream().collect(Collectors.joining(" ")).trim();
//
//        // 从命令中提取命令的key, command为add
//        String command = findLongestCommand(line);
//
//        // 将输入的命令按空白符分隔为列表, words为: ["add","2","3"]
//        List<String> words = input.words();
//        if (command != null) {
//            // 从shell.methodTarget 中获取命令对应的方法信息
//            MethodTarget methodTarget = methodTargets.get(command);
//            // 获取限制命令是否可用的条件定义
//            Availability availability = methodTarget.getAvailability();
//
//            // 判断命令是否可用
//            if (availability.isAvailable()) {
//                // 获取命令参数, wordsForArgs 为["2","3"]
//                List<String> wordsForArgs = wordsForArguments(command, words);
//
//                // 获取命令对应的方法
//                Method method = methodTarget.getMethod();
//
//                try {
//                    // 解析校验参数
//                    Object[] args = resolveArgs(method, wordsForArgs);
//                    validateArgs(args, methodTarget);
//
//                    // 反射调用方法, 并返回方法返回值
//                    return ReflectionUtils.invokeMethod(method, methodTarget.getBean(), args);
//                }
//                catch (Exception e) {
//                    return e;
//                }
//            } else {
//                //命令不可用, 返回命令不可用异常. CommandNotCurrentlyAvailable 继承了 RuntimeException
//                return new CommandNotCurrentlyAvailable(command, availability);
//            }
//        } else {
//            // 命令找不到, 返回命令找不到异常.CommandNotFound 继承了 RuntimeException
//            return new CommandNotFound(words);
//        }
//    }
//
//
//}
